home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 1 / Cream of the Crop 1.iso / WINDOWS / CLIPSTAC.ARJ / FILE.CPP < prev    next >
C/C++ Source or Header  |  1992-03-27  |  10KB  |  463 lines
  1. // file.cpp
  2.  
  3. #include"file.h"
  4. #include<malloc.h>
  5. #include<memory.h>
  6.  
  7.  
  8. int File::Offset(long offset)         
  9.     {   
  10. #if defined(_Windows)
  11.     if(lseek(fh,offset,SEEK_SET) == -1)
  12.         return -1;
  13.     return 0;
  14. #else
  15.     return fseek(fp,offset,SEEK_SET);   
  16. #endif
  17.     }
  18.  
  19. #if defined(_Windows)
  20. WORD File::ReadAt(DWORD offset, WORD size, void far *buf)
  21.     {
  22.     if(!Offset((long)offset))
  23.         return Read(size,buf);
  24.     return 0;
  25.     }
  26.  
  27. DWORD File::ReadAt(DWORD offset, DWORD size, void far *buf)
  28.     {
  29.     if(!Offset((long)offset))
  30.         return Read(size,buf);
  31.     return 0;
  32.     }
  33.  
  34. WORD File::Read(WORD size,void far *buf)
  35.     {
  36.     WORD bytesread = 0;
  37.     _dos_read(fh,buf,size,&bytesread);
  38.     return bytesread;
  39.     }
  40.  
  41. DWORD File::Read(DWORD size,void far *buf)
  42.     {
  43.     char huge *p = (char huge *)buf;
  44.     DWORD totalbytesread = 0L;
  45.     WORD bytesread;
  46.  
  47.     while(TRUE)
  48.         {
  49.         if(size >= 0x0000ffff)
  50.             {
  51.             bytesread = Read((WORD)0xffff,p);
  52.             totalbytesread += bytesread;
  53.             if(bytesread < (WORD)0xffff)
  54.                 return totalbytesread;
  55.             p += (WORD)0xffff;
  56.             size -= (WORD)0xffff;
  57.             if(size == 0L)
  58.                 return totalbytesread;
  59.             }
  60.         else
  61.             {
  62.             bytesread = Read((WORD)size,p);
  63.             totalbytesread += bytesread;
  64.             return totalbytesread;
  65.             }
  66.         }
  67.     }
  68.  
  69. WORD File::WriteAt(DWORD offset, WORD size, void far *buf)
  70.     {
  71.     if(!Offset((long)offset))
  72.         return Write(size, buf);
  73.     return 0;
  74.     }
  75.  
  76. DWORD File::WriteAt(DWORD offset, DWORD size, void far *buf)
  77.     {
  78.     if(!Offset((long)offset))
  79.         return Write(size, buf);
  80.     return 0;
  81.     }
  82.  
  83. WORD File::Write(WORD size, void far *buf)
  84.     {
  85. #ifdef OLD
  86.     int byteswritten = _lwrite(fh,(char far *)buf,size);
  87.     return byteswritten;
  88. #else
  89.     WORD byteswritten = 0;
  90.     _dos_write(fh,buf,size,&byteswritten);
  91.     return byteswritten;
  92.     }
  93. #endif
  94.  
  95. DWORD File::Write(DWORD size, void far *buf)
  96.     {
  97.     char huge *p = (char huge *)buf;
  98.     DWORD totalbyteswritten = 0L;
  99.     WORD byteswritten;
  100.  
  101.     while(TRUE)
  102.         {
  103.         if(size >= 0x0000ffffL)
  104.             {
  105.             byteswritten = Write((WORD)0xffff,p);
  106.             totalbyteswritten += byteswritten;
  107.             if(byteswritten < (DWORD)0xffff)
  108.                 return totalbyteswritten;
  109.             p += (WORD)0xffff;
  110.             size -= (WORD)0xffff;
  111.             if(size == 0L)
  112.                 return totalbyteswritten;
  113.             }
  114.         else
  115.             {
  116.             byteswritten = Write((WORD)size,p);
  117.             totalbyteswritten += byteswritten;
  118.             return totalbyteswritten;
  119.             }
  120.         }
  121.     }
  122.  
  123. #ifdef OLD
  124. void File::Append(File& fromfile, DWORD startoffset, DWORD endoffset)
  125.     {
  126.     HANDLE hMem = GlobalAlloc(GHND,0xffff);
  127.     LPSTR lpStr = GlobalLock(hMem);
  128.     unsigned bytesread;
  129.  
  130.     while(TRUE)
  131.         {
  132.         if(startoffset >= endoffset)
  133.             break;
  134.         bytesread = fromfile.ReadAt(startoffset,
  135.             (((endoffset-startoffset) > 0xffff) ? (DWORD)0xffff : (endoffset-startoffset)),
  136.             lpStr);
  137.         if(bytesread == 0)
  138.             break;
  139.         Eof();
  140.         Write((DWORD)bytesread,lpStr);
  141.         startoffset += bytesread;
  142.         }
  143.     GlobalUnlock(hMem);
  144.     GlobalFree(hMem);
  145.     }
  146. #else
  147. void File::Append(File& fromfile, DWORD startoffset, DWORD endoffset, 
  148.     LPSTR buffer)
  149.     {
  150.     HANDLE hMem;
  151.     BOOL selfalloc = FALSE;
  152.     if(buffer == NULL)
  153.         {
  154.         hMem = GlobalAlloc(GHND,0xffff);
  155.         buffer = GlobalLock(hMem);
  156.         selfalloc = TRUE;
  157.         }
  158.     unsigned bytesread;
  159.  
  160.     while(TRUE)
  161.         {
  162.         if(startoffset >= endoffset)
  163.             break;
  164.         bytesread = fromfile.ReadAt(startoffset,
  165.             (((endoffset-startoffset) > 0xffff) ? (DWORD)0xffff : (endoffset-startoffset)),
  166.             buffer);
  167.         if(bytesread == 0)
  168.             break;
  169.         Eof();
  170.         Write((DWORD)bytesread,buffer);
  171.         startoffset += bytesread;
  172.         }
  173.  
  174.     if(selfalloc)
  175.         {
  176.         GlobalUnlock(hMem);
  177.         GlobalFree(hMem);
  178.         }
  179.     }
  180. #endif
  181.  
  182.  
  183. //void File::CopyBytesUpdate(DWORD& dest, DWORD source, DWORD size)
  184.  
  185. void File::CopyBytes(DWORD dest, DWORD source, DWORD size)
  186.     {
  187.     HANDLE hMem = GlobalAlloc(GHND,size);
  188.     LPSTR lpStr = GlobalLock(hMem);
  189.     unsigned bytesread;
  190.     
  191.     if(bytesread = ReadAt(source,size,lpStr))
  192.         WriteAt(dest,(DWORD)bytesread,lpStr);
  193.     GlobalUnlock(hMem);
  194.     GlobalFree(hMem);
  195.     }
  196.    
  197. int File::Create(int attrib)
  198.     {
  199.     if((fh = _lcreat(name,attrib)) == -1)
  200.         return FALSE;
  201.     return TRUE;
  202.     }
  203.         
  204. int File::Open(WORD m)
  205.     {
  206.     if(!name)
  207.         return FALSE;
  208.     mode = m;
  209.  
  210.     if((fh = _lopen(name,mode)) == -1)
  211.         return FALSE;
  212.     return TRUE;
  213.     }
  214.  
  215. #else
  216.  
  217. int File::ReadAt(long offset, int size, void *buf)
  218.     {
  219.     if(!Offset(offset))
  220.         return Read(size,buf);
  221.     return 0;
  222.     }
  223.  
  224. int File::Read(int size,void *buf)
  225.     {
  226.     return fread(buf,1,size,fp);
  227.     }
  228.  
  229. int File::_fRead(int size, void far *farbuf, char *nearbuf)
  230.     {
  231.     if(!nearbuf)
  232.         return 0;
  233.     int bytesread = Read(size,nearbuf);
  234.     _fmemcpy(farbuf,nearbuf,bytesread);
  235.     return bytesread;
  236.     }
  237.  
  238. int File::WriteAt(long offset, int size, void *buf)
  239.     {
  240.     if(!Offset(offset))
  241.         return Write(size, buf);
  242.     return 0;
  243.     }
  244.  
  245.  
  246. int File::Write(int size, void *buf)
  247.     {
  248.     return fwrite(buf,1,size,fp);
  249.     }
  250.  
  251. int File::_fWrite(int size, void far *farbuf, char *nearbuf)
  252.     {
  253.     if(!nearbuf)
  254.         return 0;
  255.     _fmemcpy(nearbuf,farbuf,size);
  256.     int byteswritten = Write(size,(void *)nearbuf);
  257.     return byteswritten;
  258.     }
  259. int File::Open(char *m)
  260.     {
  261.     if(!name)
  262.         return FALSE;
  263.     strcpy(mode,m);
  264.  
  265.     if(!(fp = fopen(name,mode)))
  266.         return FALSE;
  267.     return TRUE;
  268.     }
  269.  
  270.  
  271. int File::Move(char *movedir)
  272.     {
  273.     if(!movedir || !*movedir)
  274.         return 1;
  275.  
  276.     char *p;
  277.     char *newname = NULL;
  278.  
  279.     if(p = strrchr(name,'\\'))
  280.         p++;
  281.     else
  282.         p = name;
  283.     newname = new char[strlen(movedir)+strlen(p)+2];
  284.     strcpy(newname,movedir);
  285.     strcat(newname,"\\");
  286.     strcat(newname,p);
  287.  
  288.     int isopen = FALSE;
  289.     char *oldmode;
  290.     if(fp)
  291.         {
  292.         isopen = TRUE;
  293.         oldmode = new char[strlen(mode)+1];
  294.         strcpy(oldmode,mode);
  295.         }
  296.  
  297.     Close();
  298.  
  299.     int retval;
  300.     if(retval = rename(name,newname))  // fall thru to no more
  301.         {
  302.         printf("Unable to rename %s to %s...press <RETURN>\n",
  303.             name,newname);
  304.         char c;
  305.         cin >> c;
  306.         }
  307.     else
  308.         SetName(newname);
  309.     if(isopen)
  310.         {
  311.         Open(oldmode);
  312.         delete oldmode;
  313.         }
  314.     if(newname)
  315.         delete newname;
  316.     return retval;
  317.     }
  318.  
  319. char *File::GetLine(void)
  320.     {
  321.     InitLineBuffer();
  322.     return fgets(linebuffer,linelen-1,fp);
  323.     }
  324.     
  325. int File::Copy(char *destination)
  326.     {
  327.     int retval = 0;
  328.  
  329. //#if defined(NOTYET)
  330.     if(!destination || !*destination)
  331.         return 1;
  332.  
  333. //   char *buffer = (char *) malloc(MAXBUF);
  334.     char *buffer = new char[MAXBUF];
  335.     if(!buffer)
  336.         return 1;
  337.  
  338.     File oldf(name);
  339.     File newf(destination);
  340.  
  341.     if(!oldf.Open("rb") || !newf.Open("wb")) 
  342.         {
  343.         delete buffer;
  344.         cout << "Unable to open source or destination file\n";
  345.         return 1;
  346.         }
  347.  
  348.     int num;
  349.     while(num = oldf.Read(MAXBUF,buffer))
  350.         newf.Write(num,(void *)buffer);
  351.     newf.Close();
  352.     oldf.Close();
  353. //#endif
  354.   delete buffer;
  355. //    free(buffer);
  356.     return retval;
  357.     }
  358.  
  359. #endif
  360.  
  361. long File::Size(void)
  362.     {
  363. #if defined(_Windows)
  364.     if(fh)
  365.         return filelength(fh);
  366. #else
  367.     if(fp)
  368.         return filelength(fileno(fp));
  369. #endif
  370.     FindFile f(name,ALL_FILES);
  371.     if(f.Found())
  372.         return f.Size();
  373.     return 0L;
  374.     }
  375.  
  376. int File::Delete(void)
  377.     {
  378. #if defined(_Windows)
  379.     if(fh)
  380. #else
  381.     if(fp)
  382. #endif
  383.         Close();
  384.     return remove(name);
  385.     }
  386.  
  387.  
  388. void File::Close(void)             
  389.     {   
  390. #if defined(_Windows)
  391.     if(fh)
  392.         {
  393.         _lclose(fh);
  394.         fh = 0;
  395.         }
  396. #else
  397.     if(fp)
  398.         {
  399.         fclose(fp);
  400.         fp = NULL;
  401.         }
  402. #endif
  403.     }
  404.  
  405.  
  406. void File::SetName(char *newname)    
  407.     {
  408.     if(name)
  409.         delete name;
  410.     name = new char[strlen(newname)+1];
  411.     strcpy(name,newname);
  412.     }
  413.  
  414. File::~File(void)
  415.     {
  416.     Close();
  417.     if(linebuffer)
  418.         {
  419.         delete linebuffer;
  420.         linebuffer = NULL;
  421.         }
  422.     if(name)
  423.         {
  424.         delete name;
  425.         name = NULL;
  426.         }
  427.     }
  428.  
  429. File::File(char *newname)         
  430.     {   
  431.     Init();
  432.     SetName(newname);   
  433.     }
  434.  
  435. void File::Init(void)
  436.     {
  437.     linelen = DEFAULTLINELEN;
  438.     linebuffer  = NULL;
  439.     name = NULL;
  440.     MAXBUF = 20000;
  441. #if defined(_Windows)
  442.     fh = 0;
  443.     mode = 0;
  444. #else
  445.     fp = NULL;
  446.     *mode = NULL;
  447. #endif
  448.     }
  449.  
  450. void File::InitLineBuffer(void)
  451.     {
  452.     if(!linebuffer)
  453.         linebuffer = new char[linelen];
  454.     }
  455.  
  456. void File::SetLineBuffer(void)
  457.     {
  458.     if(linebuffer)
  459.         delete linebuffer;
  460.     linebuffer = NULL;
  461.     InitLineBuffer();
  462.     }
  463.